home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / netz / envoyempire / source / icegui.c < prev   
C/C++ Source or Header  |  1995-07-10  |  20KB  |  666 lines
  1. #include "defines.h"
  2. #include "guidefines.h"
  3. #include "struct.h"
  4. #include "stdarg.h"
  5. #include "externalprototypes.h"
  6.  
  7. /* this code is how the server communicates with the GUI */
  8. int  changeplayer(void);
  9. extern int planetnumber;
  10. extern LONG GALAXY;
  11. extern struct MsgPort *client;
  12. extern struct planet **planetlist;
  13. extern struct sector   **SECTOR;
  14. extern struct player *currentplayer;
  15. extern ULONG signals;
  16. extern struct MsgPort *in,*out,*dataport;
  17. extern short chan;
  18.  
  19. extern BOOL insector(int,int,int);
  20. BOOL   SafePutMsg(struct Message *message, STRPTR portname);
  21. ULONG  guiinput(void);
  22. int    guiset(struct MsgPort *,LONG datasize,LONG object,LONG method,LONG data); 
  23. int    guiget(struct MsgPort *,LONG datasize,LONG object,LONG method,APTR data); 
  24. int    guiDoMethod(struct MsgPort *, LONG,LONG,LONG object,ULONG data,...);
  25. int    senddata (struct MsgPort *in, struct MsgPort *out,int length, short datatype,LONG *data);
  26. LONG   guiRequest(LONG id); 
  27. void   *getdata(LONG datatype);
  28. int    imagesetup (void);
  29. int    mapsetup(struct MsgPort *);
  30. int    empiresetup (struct MsgPort *client);
  31.  
  32.  
  33. ULONG guiinput ()
  34. {
  35.   return(0); /* dummy fuction */
  36.  
  37. }
  38.  
  39. int imagesetup ()
  40. {
  41.   return(0); /* dummy function */
  42. }
  43.  
  44.  
  45. LONG guiRequest(LONG id) {
  46.   
  47.   LONG *tempdata; 
  48.   LONG length = sizeof(LONG)*4;  
  49.   tempdata = AllocVec(length,MEMF_CLEAR);
  50.         
  51.   /* send data for sending */              
  52.   
  53.   /* 
  54.    * put up a requestor on a client's machine 
  55.    */
  56.   
  57.   if (!out) return(0);
  58.   if (tempdata) {
  59.     tempdata[0]  = GUI_REQUEST; /* message type */
  60.     tempdata[1]  = sizeof(LONG);/* data length  */
  61.     tempdata[2]  = 0;           /* no object    */
  62.     tempdata[3]  = id;          /* actual data  */
  63.     senddata(in,out,length,CSDATA,tempdata);
  64.     /* release memory */
  65.     FreeVec(tempdata);
  66.   }
  67.  
  68.   return(0);
  69. }
  70.  
  71.  
  72. int senddata (struct MsgPort *in, struct MsgPort *out,int length, short datatype, LONG *data) {
  73.   
  74.   struct MuxMsg *mmsg;
  75.   
  76.   /*
  77.    * send data to the IceBBS for sending to the client
  78.    */
  79.   
  80.   if (!out) return(0); /* make sure port is available */
  81.   if (mmsg = (struct MuxMsg *) AllocMem(SIZE(MuxMsg), MEMF_CLEAR)) {
  82.      mmsg->Length = length;
  83.      if (mmsg->Data = (UBYTE *) AllocMem(length, MEMF_CLEAR))
  84.        {
  85.        memcpy(&mmsg->Data[0],data,length);
  86.        mmsg->Type = datatype;
  87.        mmsg->priority = 0;
  88.        mmsg->msg.mn_ReplyPort = in;
  89.        PutMsg(out, (struct Message *) mmsg);  /** send message **/
  90.        }
  91.      else {
  92.         FreeMem(mmsg,SIZE(MuxMsg));
  93.         return(1);
  94.      }
  95.   }
  96.   if (length >240) printf("sending %d bytes\n",length); 
  97.   return(0);
  98. }
  99.  
  100.  
  101. int guiset(struct MsgPort *client,LONG datasize,LONG object,LONG method,LONG data) {
  102.  
  103.   
  104.   LONG *tempdata; 
  105.   LONG length =0;
  106.   struct player *player;
  107.   
  108.   /* 
  109.    * do a setAttrs on a client's machine 
  110.    */
  111.   
  112.   out = client;
  113.   if (!out) return(0);
  114.   
  115.   /* 
  116.    * need to know datasize
  117.    */
  118.    
  119.   switch (datasize) {
  120.      case INT:
  121.        length = sizeof(LONG);
  122.        break;
  123.      case SMALLSTRING:
  124.        length = sizeof(char[30]);
  125.        break;
  126.      case LARGESTRING:
  127.        length = sizeof(char[100]);
  128.        break;
  129.      case CARGO:
  130.        length = sizeof(struct tagchar);
  131.        break;
  132.      case FLEET:
  133.        length = sizeof(struct force);
  134.        break;
  135.      case ITEM:
  136.        length = sizeof(struct item);
  137.        break;
  138.      case SHIPTAG:
  139.        length = sizeof(struct shiptag);
  140.        break;  
  141.      case SHIP:
  142.        length = sizeof(struct ship);
  143.        break;  
  144.   }
  145.  
  146.   tempdata = AllocVec(sizeof(LONG)*4+length,MEMF_CLEAR);
  147.   /*
  148.   printf("sending a guiset\n");   
  149.   */
  150.   /* send data for sending */              
  151.   if (tempdata) {
  152.     tempdata[0] = GUI_SETUPDATE;
  153.     tempdata[1] = length;   /* data length */
  154.     tempdata[2] = object;
  155.     tempdata[3] = method;
  156.     if (datasize == INT) tempdata[4] = data;
  157.     else if (data) memcpy(&tempdata[4],data,length);
  158.       else {
  159.         tempdata[4] = NULL;
  160.         tempdata[1] = sizeof(LONG);
  161.         }
  162.     if (out) senddata(in,out,4*sizeof(LONG)+length,CSDATA,tempdata);
  163.     else {
  164.         player = headplayer;
  165.         while(player) {
  166.            if (player->messageport) senddata(in,player->messageport,4*sizeof(LONG)+length,CSDATA,tempdata);
  167.            player = player->next;
  168.         }
  169.     }
  170.     
  171.     /* release memory */
  172.     FreeVec(tempdata);
  173.   }
  174.   
  175.   return(0);
  176. }  
  177.  
  178. void *getdata(LONG datatype) {
  179.   
  180.   static int  number;
  181.   static char smallstring[30];
  182.   static char largestring[100];
  183.   static struct tagchar cargotag;
  184.   static struct force fleet;
  185.   static struct temp displayfleet;
  186.   static struct item item;
  187.   static struct shiptag shiptag;
  188.   static struct ship ship;
  189.   struct player *player;
  190.   LONG messagetype; 
  191.   void *pointer1,*pointer2;
  192.   struct MuxMsg *mmsg;
  193.   BOOL quit=FALSE;
  194.   LONG *message;
  195.   ULONG mysig=NULL,portflag=NULL;
  196.   
  197.   /* 
  198.    * wait for retrieved data, I need to put in a time to abort a request
  199.    */
  200.   
  201.   portflag = 1L << dataport->mp_SigBit;
  202.   
  203.   while (!quit) {
  204.     if (!out) return (NULL);
  205.     mysig = Wait(portflag | SIGBREAKF_CTRL_C); /* wait for requested info */  
  206.   
  207.     if (mysig & portflag) { 
  208.       while (mmsg = (struct MuxMsg *) GetMsg(dataport))
  209.         {
  210.            if (mmsg->msg.mn_ReplyPort == in)
  211.            {
  212.            if (mmsg->Data && mmsg->Length && (mmsg->Type == CSDATA)) 
  213.              
  214.              FreeMem(mmsg->Data, mmsg->Length);
  215.              FreeMem(mmsg, SIZE(MuxMsg));
  216.            }
  217.            else if (mmsg->Type == CSDATA) {
  218.                message = (LONG *)mmsg->Data;
  219.                messagetype = message[0];
  220.                pointer1 = &message[1];
  221.                pointer2 = NULL;
  222.                /*
  223.                printf("received messagetype %d\n",messagetype);
  224.                */
  225.                if (messagetype == GUI_NULL) return (NULL);
  226.                
  227.                switch (datatype) {
  228.                  case INT:
  229.                     memcpy(&number,pointer1,sizeof(number));
  230.                     pointer2 = (void *)number;
  231.                     break;
  232.                  case SMALLSTRING:
  233.                     memcpy(smallstring,pointer1,sizeof(smallstring));
  234.                     pointer2 = smallstring;
  235.                     break;
  236.                  case LARGESTRING:
  237.                     memcpy(largestring,pointer1,sizeof(largestring));
  238.                     pointer2 = largestring;
  239.                     break;
  240.                  case CARGO:
  241.                     memcpy(&cargotag,pointer1,sizeof(cargotag));
  242.                     pointer2 = &cargotag;
  243.                     break;
  244.                  case FLEET:
  245.                     memcpy(&fleet,pointer1,sizeof(fleet));
  246.                     pointer2 = &fleet;
  247.                     break;
  248.                  case TEMPFLEET:
  249.                     memcpy(&displayfleet,pointer1,sizeof(displayfleet));
  250.                     pointer2 = &displayfleet;
  251.                     break;
  252.                  case ITEM:
  253.                     memcpy(&item,pointer1,sizeof(item));
  254.                     pointer2 = &item;
  255.                     break;
  256.                  case SHIPTAG:
  257.                     memcpy(&shiptag,pointer1,sizeof(shiptag));
  258.                     pointer2 = &shiptag;
  259.                     break;
  260.                  case SHIP:
  261.        
  262.                     memcpy(&ship,pointer1,sizeof(ship));
  263.                     pointer2 = &ship;
  264.                     break;  
  265.                  default:
  266.                     break;
  267.                  }
  268.               ReplyMsg((struct Message *) mmsg);
  269.               return(pointer2);
  270.            }
  271.            else if (mmsg->Type == SCKILL)
  272.            {
  273.              player = headplayer;
  274.                while (player) {
  275.                   if (player->messageport == mmsg->msg.mn_ReplyPort) {
  276.                      player->messageport = NULL;
  277.                      printf("player %s has disconnected\n",player->name);
  278.                      break;
  279.                   }
  280.                   player = player->next;
  281.                }
  282.              ReplyMsg((struct Message *) mmsg);
  283.              Delay(30L);
  284.              return (NULL);
  285.            }
  286.            else if (mmsg->Type == DIENOW)
  287.            {
  288.              player = headplayer;
  289.                while (player) {
  290.                   if (player->messageport == mmsg->msg.mn_ReplyPort) {
  291.                      player->messageport = NULL;
  292.                      printf("player %s has unexpectedly disconnected\n",player->name);
  293.                      break;
  294.                   }
  295.                   player = player->next;
  296.                }
  297.              ReplyMsg((struct Message *) mmsg);
  298.              Delay(30L);
  299.              return (NULL);
  300.            }
  301.          }
  302.       }
  303.       if (mysig & SIGBREAKF_CTRL_C) return (NULL);
  304.   }     
  305.   
  306.   return(NULL);
  307. }
  308.  
  309. int guiget(struct MsgPort *client,LONG datasize,LONG object,LONG method,APTR data) {
  310.  
  311.  
  312. APTR *temp;
  313. LONG *tempdata;
  314. LONG length =0;
  315.   
  316.   out = client;
  317.   if (!out) return(0);
  318.   switch (datasize) {
  319.      case INT:
  320.        length = sizeof(LONG);
  321.        break;
  322.      case SMALLSTRING:
  323.        length = sizeof(char[30]);
  324.        break;
  325.      case LARGESTRING:
  326.        length = sizeof(char[100]);
  327.        break;
  328.      case CARGO:
  329.        length = sizeof(struct tagchar);
  330.        break;
  331.      case FLEET:
  332.        length = sizeof(struct force);
  333.        break;
  334.      case ITEM:
  335.        length = sizeof(struct item);
  336.        break;
  337.      case SHIPTAG:
  338.        length = sizeof(struct shiptag);
  339.        break;
  340.      case SHIP:
  341.        length = sizeof(struct ship);
  342.        break;
  343.        
  344.   }
  345.  
  346.   tempdata = AllocVec(sizeof(LONG)*5,MEMF_CLEAR);
  347.   /* send data for sending */              
  348.   if (tempdata) {
  349.     tempdata[0] = GUI_GET;
  350.     tempdata[1] = length;
  351.     tempdata[2] = object;
  352.     tempdata[3] = method;
  353.     tempdata[4] = (LONG)data;
  354.     senddata(in,out,5*sizeof(LONG),CSDATA,tempdata);
  355.     temp = (APTR *)(data);
  356.     FreeVec(tempdata);
  357.     *temp = getdata(datasize);
  358.     }
  359.              
  360. /*
  361.   if (data = getdata(CHAR));
  362. */
  363.   return (0);
  364. } 
  365.  
  366. int guiDoMethod(struct MsgPort *client, LONG message, LONG datatype,LONG object,ULONG data,...) {
  367.  
  368. LONG length=0;
  369. LONG *tempdata;
  370. va_list argptr;
  371. APTR *temp;
  372.  
  373.   
  374.   va_start(argptr,data); /* intialize var args */
  375.   out = client; 
  376.   if (!out) return(0);
  377.   switch (datatype) {
  378.      case INT:
  379.        length = sizeof(LONG);
  380.        break;
  381.      case SMALLSTRING:
  382.        length = sizeof(char[30]);
  383.        break;
  384.      case LARGESTRING:
  385.        length = sizeof(char[100]);
  386.        break;
  387.      case CARGO:
  388.        length = sizeof(struct tagchar);
  389.        break;
  390.      case FLEET:
  391.        length = sizeof(struct force);
  392.        break;
  393.      case TEMPFLEET:
  394.        length = sizeof(struct temp);
  395.        break;
  396.      case ITEM:
  397.        length = sizeof(struct item);
  398.        break;
  399.      case SHIPTAG:
  400.        length = sizeof(struct shiptag);
  401.        break;
  402.      case SHIP:
  403.        length = sizeof(struct ship);
  404.        break;  
  405.      default:
  406.        length = 0;
  407.        break;
  408.   }
  409.   
  410.   switch (message) {
  411.      case GUI_DOMETHODGET3:
  412.      /* if data length is 0, just pass message, if data = 1, then
  413.         we expect data back */
  414.         /* make memory for transfer of stack data */
  415.         tempdata = AllocVec(sizeof(LONG)*5,MEMF_CLEAR);
  416.         
  417.         /* send data for sending */              
  418.         if (tempdata) {
  419.           tempdata[0] = GUI_DOMETHODGET3;
  420.           tempdata[1] = length;
  421.           tempdata[2] = object;
  422.           tempdata[3] = data;
  423.           tempdata[4] = va_arg(argptr,LONG);
  424.           senddata(in,out,5*sizeof(LONG),CSDATA,tempdata);
  425.           temp = (APTR *)tempdata[4];
  426.           FreeVec(tempdata);
  427.           if (length) {
  428.             *temp = getdata(datatype);
  429.             }
  430.           }
  431.         break;
  432.         
  433.      case GUI_DOMETHODGET4:
  434.         /* need info and message reply is needed */
  435.         /* make memory for transfer of stack data */
  436.         tempdata = AllocVec(sizeof(LONG)*6,MEMF_CLEAR);
  437.         /* send data for sending */              
  438.         if (tempdata) {
  439.           tempdata[0] = GUI_DOMETHODGET4;
  440.           tempdata[1] = length;
  441.           tempdata[2] = object;
  442.           tempdata[3] = data;
  443.           tempdata[4] = va_arg(argptr,LONG);
  444.           tempdata[5] = va_arg(argptr,LONG);
  445.           senddata(in,out,6*sizeof(LONG),CSDATA,tempdata);
  446.           temp = (APTR *)tempdata[5];
  447.           *temp = getdata(datatype);
  448.           if (!*temp) temp = NULL; 
  449.           FreeVec(tempdata);
  450.         }
  451.         break;
  452.      
  453.      case GUI_DOMETHODGET5:
  454.         /* inserting data, no return is needed */
  455.         tempdata = AllocVec(sizeof(LONG)*7+length,MEMF_CLEAR);
  456.         /* send data for sending */              
  457.         if (tempdata) {
  458.           tempdata[0] = GUI_DOMETHODGET5;
  459.           tempdata[1] = length;
  460.           tempdata[2] = object;
  461.           tempdata[3] = data;
  462.           tempdata[4] = va_arg(argptr,LONG);
  463.           tempdata[5] = va_arg(argptr,LONG);
  464.           tempdata[6] = va_arg(argptr,LONG);
  465.           if (datatype != INT) memcpy(&tempdata[7],*(LONG *)tempdata[4],length);
  466.           else memcpy(&tempdata[7],&tempdata[4],length);
  467.           senddata(in,out,7*sizeof(LONG)+length,CSDATA,tempdata);
  468.           FreeVec(tempdata);
  469.         }
  470.         break;
  471.  
  472.   }
  473.   va_end(argptr); /* end macro */
  474.   return (0);
  475.   
  476. }
  477.  
  478. int empiresetup (struct MsgPort *client) {
  479.  
  480.   struct Empires newempire;
  481.   struct player *player;
  482.   struct computerplayer *computerplayer;
  483.   LONG *data;
  484.   LONG message[3];
  485.   
  486.   message[0] = GUI_EMPIRECLEAR;
  487.   senddata(in,client,3*sizeof(LONG),CSDATA,&message[0]);    
  488.   
  489.   player = headplayer;
  490.   while (player) {
  491.      strcpy(newempire.name,player->empire);
  492.      newempire.id = player->id;
  493.      
  494.      data = AllocVec(sizeof(struct Sector)+sizeof(LONG),MEMF_CLEAR|MEMF_ANY);
  495.      if (data) {
  496.         data[0] = GUI_EMPIRE;
  497.         memcpy(&data[1],&newempire,sizeof(struct Empires));      
  498.         senddata(in,client,sizeof(struct Empires)+sizeof(LONG),CSDATA,data);
  499.         FreeVec(data); 
  500.      }
  501.      player = player->next;
  502.   }
  503.   
  504.   computerplayer = headcomputerplayer;
  505.   while (computerplayer) {
  506.      strcpy(newempire.name,computerplayer->empire);
  507.      newempire.id = computerplayer->id;
  508.      
  509.      data = AllocVec(sizeof(struct Sector)+sizeof(LONG),MEMF_CLEAR|MEMF_ANY);
  510.      if (data) {
  511.         data[0] = GUI_EMPIRE;
  512.         memcpy(&data[1],&newempire,sizeof(struct Empires));      
  513.         senddata(in,client,sizeof(struct Empires)+sizeof(LONG),CSDATA,data);
  514.         FreeVec(data); 
  515.      }
  516.      computerplayer = computerplayer->next;
  517.   }
  518.     
  519.   return(0);
  520. }
  521.  
  522. int mapsetup (struct MsgPort *client) {
  523.  
  524.       int n,m;
  525.       BOOL enemy=FALSE,friendly=FALSE,send = FALSE;
  526.       struct force *fleet;
  527.       struct TagItem *tag;
  528.       struct Sector newsector;
  529.       LONG *data;
  530.       LONG message[3];
  531.       
  532.       message[0] = GUI_MAPCLEAR;
  533.       senddata(in,client,3*sizeof(LONG),CSDATA,&message[0]);    
  534.       
  535.       if (!currentplayer) return(0);
  536.         for (n=0;n<GALAXY;n++) {
  537.           for (m=0;m<GALAXY;m++) {
  538.             send                    = FALSE;
  539.             newsector.planet        = FALSE;
  540.             
  541.             if (SECTOR[n][m].PLANET) {
  542.                send = TRUE;
  543.                newsector.x             = n;
  544.                newsector.y             = m;
  545.                newsector.friendlyfleet = FALSE;
  546.                newsector.enemyfleet    = FALSE;
  547.                newsector.planet        = TRUE;
  548.                newsector.item          = FALSE;
  549.                newsector.text          = planetlist[currentplayer->id][SECTOR[n][m].PLANET->ID].textattribute;      
  550.                if (currentplayer->id == planetlist[0][SECTOR[n][m].PLANET->ID].id) newsector.planetowner = FRIENDLYPLANET;
  551.                else if (planetlist[currentplayer->id][SECTOR[n][m].PLANET->ID].id == 0) newsector.planetowner = NEUTRALPLANET;
  552.                else newsector.planetowner = ENEMYPLANET;
  553.                memcpy(&newsector.planetname,&planetlist[currentplayer->id][SECTOR[n][m].PLANET->ID].name,sizeof(char [30]));      
  554.             }
  555.           
  556.             if (insector(currentplayer->id,n,m)) {
  557.               send        = TRUE;
  558.               newsector.x = n;
  559.               newsector.y = m;
  560.  
  561.               tag = SECTOR[n][m].TAGITEM;
  562.               if (NextTagItem(&tag)) newsector.item = TRUE;
  563.               else  newsector.item = FALSE;  
  564.             
  565.               fleet = SECTOR[n][m].FLEET;
  566.               friendly = enemy = FALSE;
  567.               while (fleet) {
  568.                 if (fleet->id == currentplayer->id) friendly = TRUE;
  569.                 else enemy = TRUE;
  570.                 fleet = fleet->sectornext;
  571.               }
  572.               if (friendly) newsector.friendlyfleet = TRUE;
  573.                 else newsector.friendlyfleet = FALSE;
  574.               if (enemy)    newsector.enemyfleet = TRUE;
  575.                 else  newsector.enemyfleet = FALSE; 
  576.           }
  577.           if (send) {
  578.            data = AllocVec(sizeof(struct Sector)+sizeof(LONG),MEMF_CLEAR|MEMF_ANY);
  579.            if (data)
  580.              data[0] = GUI_MAP;
  581.              memcpy(&data[1],&newsector,sizeof(struct Sector));      
  582.              senddata(in,client,sizeof(struct Sector)+sizeof(LONG),CSDATA,data);
  583.              FreeVec(data); 
  584.            }
  585.         }
  586.       }
  587.   
  588.   return(0);
  589. }
  590.  
  591. int changeplayer() {
  592.   
  593.   int x,n,m;
  594.   char *p;
  595.   struct TagItem *tag,*tstate;
  596.   struct ship *tempship;
  597.   struct player *player;
  598.   struct tagchar *cargo = NULL,cargotag;
  599.   
  600.   if (!currentplayer) return(0);
  601.   out = currentplayer->messageport;
  602.     
  603.   if ((playernumber > 1) && (client == 0)) {
  604.     guiset(out,INT,WI_MOVEMENT,MUIA_Window_Open,FALSE);
  605.     guiset(out,INT,WI_FLEETCARGO,MUIA_Window_Open,FALSE);
  606.   }
  607.   currentplayer->currentfleet = currentfleet = currentplayer->nextfleet;
  608.   guiDoMethod(out,GUI_DOMETHODGET3,0,LV3,MUIM_List_Clear,TRUE);
  609.  
  610.   for (x=0;x<planetnumber;x++) {
  611.     n=planetlist[currentplayer->id][x].x;
  612.     m=planetlist[currentplayer->id][x].y;
  613.     p = planetlist[currentplayer->id][x].name;
  614.     SECTOR[n][m].PLANET=&planetlist[currentplayer->id][x];
  615.     guiDoMethod(out,GUI_DOMETHODGET5,SMALLSTRING,LV3,MUIM_List_Insert,&p,1,MUIV_List_Insert_Bottom);
  616.   }
  617.   x = findplanet(-1,1);
  618.   currentplayer->planet = x;
  619.   displayplanet(x);
  620.   selectplanets();
  621.   if (x>=0) guiset(out,INT,BT_PURCHASE,MUIA_Disabled,FALSE);
  622.   else guiset(out,INT,BT_PURCHASE,MUIA_Disabled,TRUE);
  623.   
  624.   purchase(x);
  625.   currentplayer->currentplanet = &planetlist[currentplayer->id][x];
  626.   selectplanets();
  627.   empiresetup(out);
  628.   mapsetup(out);
  629.   display(currentplayer);
  630.   fleetlist(currentplayer->nextfleet);
  631.   displayfleet(currentplayer->nextfleet);
  632.   displaymessages(currentplayer);
  633.   /* insert ship information */
  634.   tstate = currentplayer->fleettag;
  635.   guiDoMethod(out,GUI_DOMETHODGET3,0,LV11,MUIM_List_Clear,TRUE); 
  636.   while (tag = NextTagItem (&tstate)) {
  637.     tempship = (struct ship *) tag->ti_Data;
  638.     guiDoMethod(out,GUI_DOMETHODGET5,SHIP,LV11,MUIM_List_Insert,&tempship,1,MUIV_List_Insert_Top);
  639.     } 
  640.   
  641.   guiset(out,INT,LV18,MUIA_List_Quiet,TRUE);
  642.   guiDoMethod(out,GUI_DOMETHODGET3,0,LV18,MUIM_List_Clear,TRUE);
  643.   player = headplayer;
  644.   while (player) {
  645.      if (currentplayer->id != player->id) {
  646.        strcpy(cargotag.name,player->empire);
  647.        cargotag.tagdata = player->id;
  648.        cargotag.tagname = (ULONG) player;
  649.        cargo = &cargotag;
  650.        guiDoMethod(out,GUI_DOMETHODGET5,CARGO,LV18,MUIM_List_Insert,&cargo,1,MUIV_List_Insert_Bottom);
  651.      }
  652.      player = player->next;  
  653.   }
  654.   guiset(out,INT,LV18,MUIA_List_Quiet,FALSE);
  655.   if(!currentfleet) guiset(out,INT,BT_MOVEMENT,MUIA_Disabled,TRUE);
  656.   else guiset(out,INT,BT_MOVEMENT,MUIA_Disabled,FALSE);
  657.   
  658.   setdisplay();
  659.   guiset(out,INT,WI_MAINWINDOW,MUIA_Window_Open,TRUE);
  660.   guiset(out,INT,WI_MESSAGES,MUIA_Window_Open,TRUE);
  661.   guiRequest(9);
  662.  
  663.   return(0);
  664. }
  665.  
  666.